home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / lib / python2.4 / test / test_bsddb.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2005-10-18  |  9.8 KB  |  358 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.4)
  3.  
  4. '''Test script for the bsddb C module by Roger E. Masse
  5.    Adapted to unittest format and expanded scope by Raymond Hettinger
  6. '''
  7. import os
  8. import sys
  9. import copy
  10. import bsddb
  11. import dbhash
  12. import unittest
  13. from test import test_support
  14. from sets import Set
  15.  
  16. class TestBSDDB(unittest.TestCase):
  17.     
  18.     def setUp(self):
  19.         self.f = self.openmethod[0](self.fname, 'c')
  20.         self.d = dict(q = 'Guido', w = 'van', e = 'Rossum', r = 'invented', t = 'Python', y = '')
  21.         for k, v in self.d.iteritems():
  22.             self.f[k] = v
  23.         
  24.  
  25.     
  26.     def tearDown(self):
  27.         self.f.sync()
  28.         self.f.close()
  29.         if self.fname is None:
  30.             return None
  31.         
  32.         
  33.         try:
  34.             os.remove(self.fname)
  35.         except os.error:
  36.             pass
  37.  
  38.  
  39.     
  40.     def test_getitem(self):
  41.         for k, v in self.d.iteritems():
  42.             self.assertEqual(self.f[k], v)
  43.         
  44.  
  45.     
  46.     def test_len(self):
  47.         self.assertEqual(len(self.f), len(self.d))
  48.  
  49.     
  50.     def test_change(self):
  51.         self.f['r'] = 'discovered'
  52.         self.assertEqual(self.f['r'], 'discovered')
  53.         self.assert_('r' in self.f.keys())
  54.         self.assert_('discovered' in self.f.values())
  55.  
  56.     
  57.     def test_close_and_reopen(self):
  58.         if self.fname is None:
  59.             return None
  60.         
  61.         self.f.close()
  62.         self.f = self.openmethod[0](self.fname, 'w')
  63.         for k, v in self.d.iteritems():
  64.             self.assertEqual(self.f[k], v)
  65.         
  66.  
  67.     
  68.     def assertSetEquals(self, seqn1, seqn2):
  69.         self.assertEqual(Set(seqn1), Set(seqn2))
  70.  
  71.     
  72.     def test_mapping_iteration_methods(self):
  73.         f = self.f
  74.         d = self.d
  75.         self.assertSetEquals(d, f)
  76.         self.assertSetEquals(d.keys(), f.keys())
  77.         self.assertSetEquals(d.values(), f.values())
  78.         self.assertSetEquals(d.items(), f.items())
  79.         self.assertSetEquals(d.iterkeys(), f.iterkeys())
  80.         self.assertSetEquals(d.itervalues(), f.itervalues())
  81.         self.assertSetEquals(d.iteritems(), f.iteritems())
  82.  
  83.     
  84.     def test_iter_while_modifying_values(self):
  85.         if not hasattr(self.f, '__iter__'):
  86.             return None
  87.         
  88.         di = iter(self.d)
  89.         while None:
  90.             
  91.             try:
  92.                 key = di.next()
  93.                 self.d[key] = 'modified ' + key
  94.             continue
  95.             except StopIteration:
  96.                 break
  97.                 continue
  98.             
  99.  
  100.         fi = iter(self.f)
  101.         while None:
  102.             
  103.             try:
  104.                 key = fi.next()
  105.                 self.f[key] = 'modified ' + key
  106.             continue
  107.             except StopIteration:
  108.                 break
  109.                 continue
  110.             
  111.  
  112.         self.test_mapping_iteration_methods()
  113.  
  114.     
  115.     def test_iteritems_while_modifying_values(self):
  116.         if not hasattr(self.f, 'iteritems'):
  117.             return None
  118.         
  119.         di = self.d.iteritems()
  120.         while None:
  121.             
  122.             try:
  123.                 (k, v) = di.next()
  124.                 self.d[k] = 'modified ' + v
  125.             continue
  126.             except StopIteration:
  127.                 break
  128.                 continue
  129.             
  130.  
  131.         fi = self.f.iteritems()
  132.         while None:
  133.             
  134.             try:
  135.                 (k, v) = fi.next()
  136.                 self.f[k] = 'modified ' + v
  137.             continue
  138.             except StopIteration:
  139.                 break
  140.                 continue
  141.             
  142.  
  143.         self.test_mapping_iteration_methods()
  144.  
  145.     
  146.     def test_first_next_looping(self):
  147.         items = [
  148.             self.f.first()]
  149.         for i in xrange(1, len(self.f)):
  150.             items.append(self.f.next())
  151.         
  152.         self.assertSetEquals(items, self.d.items())
  153.  
  154.     
  155.     def test_previous_last_looping(self):
  156.         items = [
  157.             self.f.last()]
  158.         for i in xrange(1, len(self.f)):
  159.             items.append(self.f.previous())
  160.         
  161.         self.assertSetEquals(items, self.d.items())
  162.  
  163.     
  164.     def test_set_location(self):
  165.         self.assertEqual(self.f.set_location('e'), ('e', self.d['e']))
  166.  
  167.     
  168.     def test_contains(self):
  169.         for k in self.d:
  170.             self.assert_(k in self.f)
  171.         
  172.         self.assert_('not here' not in self.f)
  173.  
  174.     
  175.     def test_has_key(self):
  176.         for k in self.d:
  177.             self.assert_(self.f.has_key(k))
  178.         
  179.         self.assert_(not self.f.has_key('not here'))
  180.  
  181.     
  182.     def test_clear(self):
  183.         self.f.clear()
  184.         self.assertEqual(len(self.f), 0)
  185.  
  186.     
  187.     def test__no_deadlock_first(self, debug = 0):
  188.         sys.stdout.flush()
  189.         if debug:
  190.             print 'A'
  191.         
  192.         (k, v) = self.f.first()
  193.         if debug:
  194.             print 'B', k
  195.         
  196.         self.f[k] = 'deadlock.  do not pass go.  do not collect $200.'
  197.         if debug:
  198.             print 'C'
  199.         
  200.         if hasattr(self.f, 'iteritems'):
  201.             if debug:
  202.                 print 'D'
  203.             
  204.             i = self.f.iteritems()
  205.             (k, v) = i.next()
  206.             if debug:
  207.                 print 'E'
  208.             
  209.             self.f[k] = "please don't deadlock"
  210.             if debug:
  211.                 print 'F'
  212.             
  213.             while None:
  214.                 
  215.                 try:
  216.                     (k, v) = i.next()
  217.                 continue
  218.                 except StopIteration:
  219.                     break
  220.                     continue
  221.                 
  222.  
  223.             if debug:
  224.                 print 'F2'
  225.             
  226.             i = iter(self.f)
  227.             if debug:
  228.                 print 'G'
  229.             
  230.             while i:
  231.                 
  232.                 try:
  233.                     if debug:
  234.                         print 'H'
  235.                     
  236.                     k = i.next()
  237.                     if debug:
  238.                         print 'I'
  239.                     
  240.                     self.f[k] = 'deadlocks-r-us'
  241.                     if debug:
  242.                         print 'J'
  243.                 continue
  244.                 except StopIteration:
  245.                     i = None
  246.                     continue
  247.                 
  248.  
  249.                 None<EXCEPTION MATCH>StopIteration
  250.             if debug:
  251.                 print 'K'
  252.             
  253.         
  254.         self.assert_(self.f.first()[0] in self.d)
  255.         k = self.f.next()[0]
  256.         self.assert_(k in self.d)
  257.         self.f[k] = 'be gone with ye deadlocks'
  258.         self.assert_(self.f[k], 'be gone with ye deadlocks')
  259.  
  260.     
  261.     def test_for_cursor_memleak(self):
  262.         if not hasattr(self.f, 'iteritems'):
  263.             return None
  264.         
  265.         nc1 = len(self.f._cursor_refs)
  266.         i = self.f.iteritems()
  267.         nc2 = len(self.f._cursor_refs)
  268.         (k, v) = i.next()
  269.         nc3 = len(self.f._cursor_refs)
  270.         del i
  271.         nc4 = len(self.f._cursor_refs)
  272.         self.assertEqual(nc1, nc2)
  273.         self.assertEqual(nc1, nc4)
  274.         self.assert_(nc3 == nc1 + 1)
  275.  
  276.     
  277.     def test_popitem(self):
  278.         (k, v) = self.f.popitem()
  279.         self.assert_(k in self.d)
  280.         self.assert_(v in self.d.values())
  281.         self.assert_(k not in self.f)
  282.         self.assertEqual(len(self.d) - 1, len(self.f))
  283.  
  284.     
  285.     def test_pop(self):
  286.         k = 'w'
  287.         v = self.f.pop(k)
  288.         self.assertEqual(v, self.d[k])
  289.         self.assert_(k not in self.f)
  290.         self.assert_(v not in self.f.values())
  291.         self.assertEqual(len(self.d) - 1, len(self.f))
  292.  
  293.     
  294.     def test_get(self):
  295.         self.assertEqual(self.f.get('NotHere'), None)
  296.         self.assertEqual(self.f.get('NotHere', 'Default'), 'Default')
  297.         self.assertEqual(self.f.get('q', 'Default'), self.d['q'])
  298.  
  299.     
  300.     def test_setdefault(self):
  301.         self.assertEqual(self.f.setdefault('new', 'dog'), 'dog')
  302.         self.assertEqual(self.f.setdefault('r', 'cat'), self.d['r'])
  303.  
  304.     
  305.     def test_update(self):
  306.         new = dict(y = 'life', u = 'of', i = 'brian')
  307.         self.f.update(new)
  308.         self.d.update(new)
  309.         for k, v in self.d.iteritems():
  310.             self.assertEqual(self.f[k], v)
  311.         
  312.  
  313.     
  314.     def test_keyordering(self):
  315.         if self.openmethod[0] is not bsddb.btopen:
  316.             return None
  317.         
  318.         keys = self.d.keys()
  319.         keys.sort()
  320.         self.assertEqual(self.f.first()[0], keys[0])
  321.         self.assertEqual(self.f.next()[0], keys[1])
  322.         self.assertEqual(self.f.last()[0], keys[-1])
  323.         self.assertEqual(self.f.previous()[0], keys[-2])
  324.         self.assertEqual(list(self.f), keys)
  325.  
  326.  
  327.  
  328. class TestBTree(TestBSDDB):
  329.     fname = test_support.TESTFN
  330.     openmethod = [
  331.         bsddb.btopen]
  332.  
  333.  
  334. class TestBTree_InMemory(TestBSDDB):
  335.     fname = None
  336.     openmethod = [
  337.         bsddb.btopen]
  338.  
  339.  
  340. class TestHashTable(TestBSDDB):
  341.     fname = test_support.TESTFN
  342.     openmethod = [
  343.         bsddb.hashopen]
  344.  
  345.  
  346. class TestHashTable_InMemory(TestBSDDB):
  347.     fname = None
  348.     openmethod = [
  349.         bsddb.hashopen]
  350.  
  351.  
  352. def test_main(verbose = None):
  353.     test_support.run_unittest(TestBTree, TestHashTable, TestBTree_InMemory, TestHashTable_InMemory)
  354.  
  355. if __name__ == '__main__':
  356.     test_main(verbose = True)
  357.  
  358.